package note_002;

public class day10 {
    //-----------------------------元素操作----------Collection接口
    /**Java.util.Collection接口，该接口是所有集合的顶级接口，里面规定了所有集合都应当具备的功能方法*/
    /**java.util.List:线性表，可以存放重复元素且有序。
     * java.util.Set:不可存放重复元素。
     * -------------------------------Java.util.Collection:所有集合的顶级接口
     */
    /** boolean add(E e):向当前集合中添加一个元素，该元素成功添加到集合中则返回true.*/
    /** .clear():清空 */
    /** int size() 返回当前集合的元素个数 */
    /** boolean isEmpty:判断是否有元素------判断当前集合是否为空集(当且仅当size==0时,isEmpty()返回true)*/
    /** remove() 从集合中删除给定元素,(List)重复元素仅删除一次 */
    //c.remove(p);// 当有元素被删除时发放返回true.
    /** boolean contains(Object o) 判断当前集合是否包含给定元素 */
    //------------------------------集合操作
    /** boolean addAll(Collection c):
     * 将给定集合中的所有元素添加到当前集合中，如果添加后当前集合发生了改变则返回true.*/
    /**
     * boolean containAll(Collection c)
     * 判断当前集合是否包含给定集合中的所有元素.
     */
    // boolean containsAll = c.containsAll(c3);
    /**
     * boolean removeAll(Collection c)
     * 删除当前集合中与给定集合的共有元素(给定集合的元素,不会被删除).
     */
    // c.removeAll(c3);
    //-------------------------------集合遍历
    /**
     * 集合的遍历
     * 集合提供了同一的遍历方式:迭代器.
     * Iterator iterator()
     * 该方法会返回一个同于遍历当前集合元素的迭代器.
     * java.util.Iterator接口是迭代器接口，规定了遍历集合的相关操作，不同的集合都提供了用于遍历
     * 自身元素的迭代器实现类。
     * 迭代器遍历集合遵循的步骤为:1.问,2.取,3.删.其中删除操作不是必须操作.
     *
     * JDK5推出时，推出了一个新的特性:  泛型   <E>:指定类型,编译器认可.
     * 泛型也称参数化类型，使得我们在使用一个类时可以指定其内部某个属性，方法参数或返回值的类型。
     * 这样使用这个类可以更灵活。
     * 泛型在集合中被广泛使用，用于定义集合中的元素类型。
     * 泛型是编译器认可的，泛型的原型是Object，指定泛型的类型可以让编译器辅助一下操作：
     * 赋值时，编译器会检查给定的值是否符合泛型指定的类型，不符合则编译不通过。
     * 获取值时，编译器会自动补充造型代码，转换为泛型指定的类型.
     * 泛型: 1.:支持引用类型;
     *      2.:不支持基本类型,可以写相应的包装类;例如:int -> Integer;
     *      用于定义集合中的元素类型;
     *      泛型的原型是Object;
     */
//    //Collection<E>声明是E用于在集合中指定元素.
//    Collection<String> c = new ArrayList<>();//指定泛型实际类型为String
//        /*
//            boolean add(E e)
//            编译器会将E当成String来检验调用该方法时实际传入的参数类型.
//            泛型:1.:支持引用类型; 2.:不支持基本类型,可以写相应的包装类;例如:int -> Integer
//         */
//        c.add("one");//检查参数类型是否为String
////        c.add(123);//编译不通过,实参类型不是String
    /**
     Iterator iterator() 迭代器.
     boolean hasNext()
     判断集合是否还有下一个元素可以遍历。第一次调用时就是判断是否有第一个元素，以此类推.

     E next()
     使迭代器获取下一个元素。第一次调用时就是获取第一个元素.

     注:迭代器默认是在集合第一个元素之前的位置.
     Iterator len = c.iterator();
     while (len.hasNext()){//问
        String str =(String)len.next();//取
        System.out.println(str);
     }
     */
    //迭代器也支持泛型，指定时与其遍历的集合指定的泛型一致即可.
//    Iterator<String> len = c.iterator();
//        while (len.hasNext()){//问
//            /*
//                迭代器指定泛型后，next方法获取元素时不需要在造型(编译器编译成Class文件时,会补充造型代码)
//             */
//        String str =len.next();//取
//        System.out.println(str);
//        if("#".equals(str)){
//                /*
//                    使用迭代器遍历集合的过程中不要通过集合的方法增删元素集合否则会出现异常.
//                    ConcurrentModificationException
//                 */
////                c.remove(str);
//                /*
//                    迭代器提供了remove方法，删除的是本次通过next方法获取的元素.
//                 */
//            len.remove();
//        }
//    }
    /**
     * JDK之后推出了一个的特性:增强型for循环也称为新循环.
     * -----作用:是遍历集合或数组。
     *          因此新循环并不取代传统for循环的工作.
     */
    /*
       新循环遍历数组会被编译器改回成普通的for循环比较数组.
     */
    /*
        新循环遍历集合会被改为迭代器遍历，因此注意:不要在遍历的过程中通过集合的方法增删元素
        否则会抛出异常.
     */
//    for(String str : c){//新循环只是编译器认可.
//        System.out.println(str);
//    }

    /**
     * java.util.List集合
     * List是一个接口，定义了List集合的相关操作，它除了具有Collection中的通用操作外还提供了一组通过，
     * 下标操作元素的方法.
     * LIst是可以存放重复元素且有序的集合，常用实现类:
     * java.util.ArrayList:内部使用数组实现，查询性能好.
     * java.util.LinkedList:内部使用链表实现. 增删性能更好，首尾增删性能最佳.
     */
    /** java.util.ArrayList:内部使用数组实现，查询性能好.*///-----java.util.List集合--->--java.util.ArrayList
    /** E get(int index):获取指定下标处对应的元素*/
    /** E set(int index, E e):(替换元素操作)*/
    //将给定的元素设置到指定的位置，返回值为该位置原有元素.
    /** Collections提供的方法.reverse():反转 */
//将集合元素反转
    //Collections.reverse(list);-----    Collection提供的方法.reverse():反转
//    for(int i=0;i<list.size()/2;i++){
//        str = list.get(i);
//        String  str1 = list.set(list.size()-1-i,str);
//        list.set(i,str1);
//    }
//        System.out.println(list);
    /**
     * List提供了一对重载的add,remove方法
     */
    /** void  add(int index,E e):将给定元素插入到指定位置 */
    //list.add(1,"ten");
        /*
            [one, two, three, 四, 5]
            [one, ten, two, three, 四, 5]
         */
    /** E remove(int index)
     *  删除指定位置上的元素，返回为被删除的元素.
     */
//    String str = list.remove(1);//remove有返回值,通过给变量str赋值并输出可以查看.
    /**
     * List subList(int start,int end)
     * 获取当期集合中指定范围内的子集，两个数字参数表示范围，含头不含尾.
     */
    /** 原集合 */
    /** 子集合 */
//    List<Integer> subList = list.subList(2,8);//获取当期集合中,指定范围内的子集
    /** 对子集的修改就是对原集合对应元素的修改b */

    /** 集合转换为数组:
     * Collection提供了方法toArray，可以将当前集合转换为一组数组.
     */
    /** toArray: 集合转换为数组 */
        /*
        集合只能存引用类型，所以不能转变为基本类型.
         */
    /** Arrays.toString():数组转字符串*/
//        Collection<String> c = new ArrayList<>();
//        Object[] arr = c.toArray();
//        String[] arr = c.toArray(new String[c.size()]);
//        System.out.println(Arrays.toString(arr));//数组转字符串:Arrays.toString()
    /**
     * 数组转换为List集合
     * 数组的工具Arrays提供了静态方法asList，可以将一个数组转换为一个List集合.
     */
    /** Arrays.asList(): 数组转换为List集合 */
    /**
     * 对子集的修改就是对原集合对应元素的修改
     */
    //影响元素个数的操作的不支持.
    /* 对集合的操作就是对元素的操作 */
        /*
            由于数组定长,因此集合会改变元素个数的操作都不支持，会抛出异常!
            UnsupportedOperationException
            list.add("?");
         */
    /**
     * 如果需要增删元素，需要自行创建一个集合同时包含数组转换的集合中的所有元素后方可随意操作.
     * String[] array = {?}
     * List<String> list = Arrays.asList(array);
     * List<String> list1 = new ArrayList<>(list);
     *     或
     * List<String> list2 = new ArrayList<>(Arrays.toString(array));
     */

    /**
     * Collection:提供了一个静态方法:
     * static void sort(List list)
     * 可以对给定的集合进行自然排序(从小到大)
     *
     * Collections.sort(?);
     */



}
